import React, { createContext, useState, useEffect, useContext } from 'react';
import keycloak from '../config/keycloak';

// 创建 Keycloak 上下文
const KeycloakContext = createContext(null);

// 初始状态
const initialState = {
  initialized: false,
  authenticated: false,
  user: null,
  keycloak: keycloak
};

// 提供 Keycloak 上下文的组件
export const KeycloakProvider = ({ children }) => {
  const [state, setState] = useState(initialState);
  
  // 更新状态的帮助函数
  const updateState = (updates) => {
    setState(prevState => ({
      ...prevState,
      ...updates
    }));
  };

  // 加载用户信息
  const loadUserProfile = async () => {
    try {
      if (state.authenticated) {
        console.log('开始加载用户信息...');
        const profile = await keycloak.loadUserProfile();
        
        // 确保获取用户 ID (subject)
        const userId = keycloak.subject || keycloak.tokenParsed?.sub;
        
        if (!userId) {
          console.error('无法获取用户 ID，用户信息加载失败');
          return;
        }
        
        const userData = {
          id: userId,
          username: profile.username,
          email: profile.email,
          firstName: profile.firstName,
          lastName: profile.lastName,
          roles: keycloak.realmAccess?.roles || []
        };
        
        updateState({ user: userData });
        console.log('用户信息加载成功:', userData);
        
        // 将用户信息同步到 localStorage 以便于调试
        localStorage.setItem('keycloak_user', JSON.stringify(userData));
      }
    } catch (error) {
      console.error('加载用户信息失败:', error);
    }
  };

  // 初始化 Keycloak
  useEffect(() => {
    console.log('Keycloak 验证已临时禁用');
    
    // 设置模拟用户
    updateState({
      initialized: true,
      authenticated: true,
      user: {
        id: 'dev-user',
        username: '开发用户',
        email: 'dev@example.com',
        roles: ['admin', 'user']
      }
    });
    
    // 原始 Keycloak 初始化代码（已注释）
    /*
    let refreshInterval;
    
    const initKeycloak = async () => {
      try {
        console.log('开始初始化 Keycloak...');
        
        // 检查本地存储中是否有保存的令牌
        const savedToken = localStorage.getItem('kc_token');
        const savedRefreshToken = localStorage.getItem('kc_refreshToken');
        
        if (savedToken && savedRefreshToken) {
          console.log('发现本地保存的令牌，尝试恢复会话');
          keycloak.token = savedToken;
          keycloak.refreshToken = savedRefreshToken;
          keycloak.refreshTokenParsed = savedRefreshToken ? JSON.parse(atob(savedRefreshToken.split('.')[1])) : null;
          
          // 检查令牌是否已过期
          const tokenExp = keycloak.refreshTokenParsed?.exp * 1000; // 转换为毫秒
          if (tokenExp && Date.now() >= tokenExp) {
            console.log('保存的令牌已过期，需要重新登录');
            localStorage.removeItem('kc_token');
            localStorage.removeItem('kc_refreshToken');
            updateState({ initialized: true, authenticated: false });
            return;
          }
        }
        
        // 初始化配置
        const authenticated = await keycloak.init({
          onLoad: 'check-sso',
          silentCheckSsoRedirectUri: window.location.origin + '/silent-check-sso.html',
          pkceMethod: 'S256',
          checkLoginIframe: false,
          enableLogging: true,
          token: savedToken,
          refreshToken: savedRefreshToken,
          refreshTokenParsed: savedRefreshToken ? JSON.parse(atob(savedRefreshToken.split('.')[1])) : null,
          flow: 'standard',
          responseMode: 'fragment'
        });
        
        console.log('Keycloak 初始化成功, 认证状态:', authenticated, '令牌:', keycloak.token ? '存在' : '不存在');
        
        // 如果认证成功，保存令牌到本地存储
        if (authenticated && keycloak.token) {
          localStorage.setItem('kc_token', keycloak.token);
          localStorage.setItem('kc_refreshToken', keycloak.refreshToken);
        }
        
        // 更新状态
        updateState({
          initialized: true,
          authenticated: authenticated
        });
        
        // 如果已认证，加载用户信息
        if (authenticated) {
          await loadUserProfile();
          
          // 清除之前的定时器（如果存在）
          if (refreshInterval) {
            clearInterval(refreshInterval);
          }
          
          // 设置令牌自动刷新
          refreshInterval = setInterval(async () => {
            try {
              const refreshed = await keycloak.updateToken(70);
              if (refreshed) {
                console.log('令牌已刷新');
                localStorage.setItem('kc_token', keycloak.token);
                localStorage.setItem('kc_refreshToken', keycloak.refreshToken);
              }
            } catch (error) {
              console.error('令牌刷新失败:', error);
              // 如果刷新失败，清除本地存储的令牌
              if (error?.error === 'login_required') {
                console.log('会话已过期，需要重新登录');
                localStorage.removeItem('kc_token');
                localStorage.removeItem('kc_refreshToken');
                updateState({ authenticated: false, user: null });
              }
            }
          }, 60000); // 每分钟检查一次
        }
      } catch (error) {
        console.error('Keycloak 初始化失败:', error);
        updateState({
          initialized: true,
          authenticated: false
        });
      }
    };

    initKeycloak();
    
    // 注册 Keycloak 事件处理程序
    keycloak.onAuthSuccess = async () => {
      console.log('Keycloak 认证成功');
      updateState({ authenticated: true });
      
      // 保存令牌到本地存储
      if (keycloak.token) {
        localStorage.setItem('kc_token', keycloak.token);
        localStorage.setItem('kc_refreshToken', keycloak.refreshToken);
      }
      
      await loadUserProfile();
    };
    
    keycloak.onAuthError = () => {
      console.error('Keycloak 认证错误');
      updateState({ authenticated: false });
    };
    
    keycloak.onAuthLogout = () => {
      console.log('Keycloak 用户登出');
      updateState({ authenticated: false, user: null });
    };
    
    // 清理函数
    return () => {
      keycloak.onAuthSuccess = undefined;
      keycloak.onAuthError = undefined;
      keycloak.onAuthLogout = undefined;
    };
    */
  }, []);

  // 登录方法
  const login = () => {
    console.log('调用 Keycloak 登录...');
    
    // 获取当前路径作为登录成功后的重定向目标
    const currentPath = window.location.pathname + window.location.search;
    sessionStorage.setItem('auth_redirect_path', currentPath);
    
    // 调用 Keycloak 登录
    keycloak.login({
      redirectUri: window.location.origin + '/login-success'
    });
  };

  // 登出方法 - 使用两步法实现完全退出
  const logout = () => {
    console.log('执行两步法退出登录...');
    
    try {
      // 第一步：先清除前端的所有状态
      // 清除所有本地存储
      const keysToRemove = [];
      for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        if (key) {
          keysToRemove.push(key);
        }
      }
      
      // 删除所有本地存储项
      keysToRemove.forEach(key => {
        console.log('清除本地存储项:', key);
        localStorage.removeItem(key);
      });
      
      // 清除所有会话存储
      sessionStorage.clear();
      
      // 清除所有 cookie
      document.cookie.split(";").forEach(function(c) {
        document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/");
      });
      
      // 重置 Keycloak 实例状态
      if (keycloak) {
        keycloak.authenticated = false;
        keycloak.token = null;
        keycloak.refreshToken = null;
        keycloak.idToken = null;
        keycloak.subject = null;
        keycloak.realmAccess = null;
      }
      
      // 更新上下文状态
      updateState({
        authenticated: false,
        user: null
      });
      
      // 第二步：在后台发送请求到 Keycloak 的退出端点，然后直接跳转到登录页面
      if (keycloak && keycloak.authServerUrl) {
        try {
          // 创建一个隐藏的 iframe 来发送退出请求
          const logoutUrl = `${keycloak.authServerUrl}/realms/${keycloak.realm}/protocol/openid-connect/logout`;
          const iframe = document.createElement('iframe');
          iframe.style.display = 'none';
          iframe.src = logoutUrl;
          document.body.appendChild(iframe);
          
          // 给服务器一点时间处理退出请求，然后直接跳转到登录页面
          console.log('在后台发送退出请求，然后将重定向到登录页面');
          
          // 给服务器一点时间处理退出请求
          setTimeout(() => {
            // 删除 iframe
            try { document.body.removeChild(iframe); } catch (e) { /* 忽略错误 */ }
            
            // 直接跳转到登录页面
            console.log('重定向到登录页面');
            window.location.href = '/login';
          }, 500);
        } catch (e) {
          console.error('发送后台退出请求失败:', e);
          // 出错时直接跳转到登录页面
          window.location.href = '/login';
        }
      } else {
        // 如果 keycloak 实例不可用，直接重定向到登录页面
        window.location.href = '/login';
      }
    } catch (error) {
      console.error('退出登录过程出错:', error);
      // 出错时直接重定向到登录页面
      window.location.href = '/login';
    }
  };

  // 获取用户ID
  const getUserId = () => {
    return state.user ? state.user.id : null;
  };

  // 获取访问令牌
  const getToken = () => {
    return keycloak.token;
  };

  // 检查用户是否有特定角色
  const hasRole = (role) => {
    return keycloak.hasRealmRole(role);
  };

  // 更新令牌
  const updateToken = async (minValidity = 5) => {
    try {
      return await keycloak.updateToken(minValidity);
    } catch (error) {
      console.error('更新令牌失败:', error);
      return false;
    }
  };

  // 提供给上下文的值
  const contextValue = {
    initialized: state.initialized,
    authenticated: state.authenticated,
    user: state.user,
    keycloak,
    login,
    logout,
    getUserId,
    getToken,
    hasRole,
    updateToken
  };

  return (
    <KeycloakContext.Provider value={contextValue}>
      {children}
    </KeycloakContext.Provider>
  );
};

// 自定义钩子，用于在组件中访问 Keycloak 上下文
export const useKeycloak = () => {
  const context = useContext(KeycloakContext);
  if (!context) {
    throw new Error('useKeycloak 必须在 KeycloakProvider 内部使用');
  }
  return context;
};
